. > TwinHelp
.library "a4atl"
.usechars
.foot
$rm $c Page ~%page
.endf
$chead _The Twin Screen editor_$chead
.blank 4
.picture "*" "100.0" "200.0"
 /acorn { /x exch def matrix currentmatrix currentpoint translate x 288 div
 dup scale /do /fill load def /s {16 div 72 mul } def /h1 36 s def /f1 .26 def
 -18 s 0 moveto -18 3 f1 mul add s h1 f1 mul s 18 3 f1 mul sub s h1 f1 mul s
 18 s 0 curveto closepath do /h2 30 s def /f2 .17 def -19 s -3 s moveto
 -19 3 f2 mul add s -3 h2 f2 mul sub s 19 3 f2 mul sub s -3 h2 f2 mul sub s
 19 s -3 s curveto closepath do -20.5 s -17.5 s moveto
 0 -23 s 0 -23 s 22 s -31 s curveto 17 s -33 s lineto
 0 -25 s 0 -25 s -21.25 s -19 s curveto closepath do
 -1.4 s -15 s moveto -1.4 s -24 s lineto 1.4 s -24 s lineto 1.4 s -15 s lineto
 closepath do setmatrix } def 0 70 moveto 36 acorn
.endpicture
.blank 4
.section Introduction
$it Twin $rm provides text file editing with particular attention being paid
to ease of use and ability to go to particular line numbers as referenced by
error line descriptions from compilers. Two windows allow references to be
easily checked and copied. $it Twin $rm is also capable of running tasks in a
window without significantly affecting use. Ten buffers allow many files to
be available.
.blank
.section Simple use of Twin
Enter $it Twin $rm by typing $tt Twin$#<filename> $rm or
$tt Twin$#<filename>$#<filename>$rm. While you are still unfamiliar with
$it Twin $rm it is best to display the "on screen help information"
using $ss Descriptive Mode$rm, accessed by typing $tt shift-f5$#D$rm.
Helpfully, $it Twin $rm will remind you how to get $ss Descriptive Mode $rm
whenever an error message is printed. In descriptive mode the top portion of
the screen displays all the function key actions and a text box describes each
red function key as it is used. $ss Descriptive mode $rm uses up a large amount
of the screen to display its information: $it Twin $rm also provides a
$ss Key Legends $rm mode, accessed by typing $tt shift-f5$#K$rm, which only
displays the function key labels.

Pressing the $tt ESCAPE $rm key gets one out of any trouble that could occur.

Characters typed on the main keyboard are entered directly into text and the
screen updated.

Normal use of the cursor keys moves by one line or character, scrolling the
document up or down if necessary.

$bf Shifted $rm use of the cursor keys moves either up and down a complete
screen display, or right or left by one word.

$bf Control $rm /|\ and $bf control \|/ $rm go to start and end of the
document respectively. $bf Control $rm <-- and --> go to start and end of
the current line.

There is a $ss status line $rm at the bottom of the screen. This contains
information about the current environment:
.display flow
.tabset 12
$ss 01$t $rm- left digit is buffer number, right digit is number of pushed buffers
$ss Insert$t $rm- characters will be inserted into the text
$ss Over$t $rm- characters will over type the existing characters

$ss TAB cols$t $rm- the TAB key moves to the next column of 8 characters
$ss TAB words$t $rm- the TAB key moves to under the next word on the above line
$ss One mark$t $rm- One mark is set
$ss Two marks$t $rm- Two marks are set

$ss Original$t $rm- the text is saved on the filing system
$ss LF <-> CR$t $rm- the text is Original, but its Line Feeds and Carriage Returns
$t ##have been interchanged.
$ss Modified$t $rm- the text has been altered since it was loaded or saved
$ss Discarded$t $rm- the text has been thrown away by replying Y to the safety prompt
$ss "<name>"$t $rm- the name of the file
$ss <data>$t $rm- (a) the date of a dated file
$t #(b) $ss **Command file** $rm if a command file, i.e. a file whose load
$t #####address is 0 and whose execution address is $tt FFFFFFFF $rm and so
$t #####will be automatically read as a series of commands by a filing system
$t #(c) the load and execute addresses of a binary file
.endd
.section Twin commands
.indent 12
.tabset 14
.tempindent 0
$tt f0 $rm $t Goto Line
.blank
$it Twin $rm prompts with the current line number (computed from the number of
$tt NewLine $rm characters before the cursor) and current character position in
the document. Possible responses are:
.newline
A straightforward number takes you to that line.
.newline
$tt m1 $rm or $tt m2 $rm takes you to that position marker.
.newline
$tt +n $rm or $tt -n $rm moves the character position by that number of
characters.
.blank 2
.tempindent 0
$tt shift f0$rm $t Display NewLine
.blank
Toggles between invisible display of NewLines (the default) and reverse video
`<--'s marking them.
.blank 2
.tempindent 0
$tt ctrl f0$rm$t Toggle Window
.blank
If there is only one window on screen, then the screen will be split and the
second window displayed and selected. If the second window is on screen then
it will become the selected window. The selected window's status bar will be
`bright'.
.blank 2
.tempindent 0
$tt ctrl shift f0$rm$t Connect to buffer
.blank
Connect a different buffer to this window. There are ten buffers named `0' to
`9'. A buffer can only be connected to one window. The buffer number is the
leftmost digit. Buffers `0' and `1' are the ones initially used.

Connect cannot be used while there are `Pushed' buffers present.
.blank 2
.tempindent 0
$tt f1$rm$t Command line
.blank
Gives the user access to Acorn MOS CLI, e.g. $tt<f1>CAT $rm for a disk catalog.
Running something (e.g. a compiler) from here will result in it returning to
$it Twin$rm.
.blank 2
.tempindent 0
$tt shift f1$rm$t Insert/Over
.blank
Toggles the character entry mode between Insert (the default) and overtype.
$ss Insert $rm or $ss Over $rm respectively is displayed at the left of the
status line to indicate the current mode of the buffer.
.blank 2
.tempindent 0
$tt ctrl f1$rm$t Expand Window
.blank
With two windows on screen the selected one will be grown until there is no
room to make it larger. The cursor positions in both windows will be kept on
screen.
.blank 2
.tempindent 0
$tt f2$rm$t Load file
.blank
Load this buffer from a named file. $it Twin $rm knows if the current text in
the buffer is $ss Original $rm or $ss Modified $rm from the previous load or
clear text. If the text has been modified then you will be asked if you wish
to continue with the load operation, which would overwrite your work.
.blank 2
.tempindent 0
$tt shift f2$rm$t Insert file
.blank
Insert text from a named file at the cursor position
.blank 2
.tempindent 0
$tt ctrl f2$rm$t Close Window
.blank
If there is only one window on screen then it will be deselected and the other
window shown. If there are two windows on screen then the current window will
be removed from the screen, the other one becoming full screen. Text in a
deselected window is not harmed - you just can't see it!.
.blank 2
.tempindent 0
$tt ctrl shift f2$rm$t Load file using *path
.blank
Performs the Load file (ordinary f2) action, but using the file $tt *path $rm
(thus equating to m2path or cpath or twinpath: whichever ADFS provides) to
search in places other than the current directory. The format of the
$tt *path $rm file for Twin is as follows:
$tt <directory name><delimiter> $rm
repeated as often as necessary. $tt <delimiter> $rm is one of `~~|', LF
(character 10) or CR (character 13). Twin will have kittens otherwise! The
$tt <directory name> $rm can be relative to the current directory. A useful
$tt *path $rm file might be:
.display flow
|$.arm.m2.library|$.arm.m2.otherlib
.endd
The null pathname before the first delimiter lets Twin try the current
directory, which would not be tried otherwise. The $tt *path $rm file must not
be longer than 1024 bytes.

When the file has been successfully found the full path name will be put in
the file name position on the status line: it can thus be used by $tt COPY$rm.

If the *path could not be found, the file system's error message
($tt#Not#Found#$rm in the case of ADFS) will be displayed instead of the
normal Twin $tt File Not Found $rm error message.
.blank 2
.tempindent 0
$tt f3$rm$t Save file
.blank
Save the text to a named file. Reset to $ss Original$rm. $it Twin $rm stamps a
date stamped file at this time if it has been modified. If there is one mark
$it Twin $rm will save from mark to cursor (and prompt accordingly). Twin makes
a quiet beep to remind you that you have pressed save.
.blank 2
.tempindent 0
$tt shift f3$rm$t Change Margins
.blank
$it Twin $rm scrolls the screen when the cursor is 4 lines or less from the
edge of the screen. Remove Margins (type $tt R$rm) causes this to happen right
at the edge. Set top margin (type $tt T$rm) sets the top scroll position to
the cursor line, similarly set bottom margin (type $tt B$rm). Margins will be
reset to $it Twin $rm's preferred positions if the size of the window is
altered (by $it Expand Window, Toggle Window, Close Window, change screen mode$rm).
.blank 2
.tempindent 0
$tt ctrl f3$rm$t Next Line
.blank
$it Twin $rm can read the error messages from compiler output and go to the
offending lines in the source file. Next Line looks for the text $tt "$#line$#" $rm
(in any case of characters) in the other text buffer: if found it then treats
the following text as input to a Goto line operation; obviously only the
absolute line number option is of real interest.
.blank 2
.tempindent 0
$tt f4$rm$t Find String
.blank
enter the interactive find and replace option. A prompt of
.newline
$tt _Find$#and$#replace: _$rm
.newline
will appear at the bottom of the screen. The text
up to $tt RETURN $rm (or, as we will see, $tt f5$rm) is the string to be
searched for (with case equality). The function keys provide powerful "meta"
characters in the search (and replace) strings: when used they will print a
brief version of their job in reverse video.
.display flow
$tt _Key       Brief     meaning_

$tt f0        Newline   $rm the NewLine character, usually LF, 10
$tt f1        Field~~#    $rm followed by 0 to 9: the nth "wild" section found
$tt f2        Found     $rm the entire found string
$tt f3        Most      $rm the most possible matches for the following item
$tt f4        Many      $rm as many matches of the following item as necessary
$tt f5         by       $rm begin the replace part of the string
$tt f6        Not       $rm match not the next item
$tt f7        Any       $rm matches any character at all
$tt f8        Alpha     $rm matches A to Z, a to z, 0 to 9 and ~~_
$tt f9        Number    $rm matches 0 to 9
$tt shift f0  Set[      $rm begin set of items to match
$tt shift f1  ]Set      $rm end set of items
$tt shift f2  to        $rm range eg. $tt A_to_Z $rm
$tt shift f3  Control   $rm Control the following item: $tt_Control_M $rm is &0D
$tt shift f4  TopBit    $rm sets top bit of following item
$tt shift f5  Exact     $rm if worried about possible use of character, in
$tt ####################$rm particular case equality: $tt_Exact_A $rm matches only
$tt ####################$rm upper case A.
$tt shift f6  Case      $rm Toggle case equality flag: (initially case equality is
$tt ####################$rm selected) _Case_Fred matches only Fred (not FRED).

Examples of search strings:

$tt hello#########$rm look for 'hello'
$tt he_Many_lo######$rm look for 'heo' 'helo' 'hello' 'helllo' etc.
$tt _Many_ _Control_J#$rm look for a spaces followed by line feed
$tt _ManyAlpha_#####$rm look for a word
.endd
If the string is ended in a $tt RETURN $rm i.e. no $tt f5 $rm
$tt_$#by$#_$rm, then the string will be found (if possible) and a prompt of
.newline
$tt C(ontinue), E(end of file replace), R(eplace) or ESCAPE $rm
.newline
will be displayed. $tt C $rm moves on to the next occurence, $tt E $rm
replaces the found strings until the end of file, $tt R $rm replaces and moves
on, $tt ESCAPE $rm or $tt RETURN $rm stop altogether, and any $it Twin $rm
command (red key or cursor movement or $tt DELETE$rm) leaves this state and
carries out the command. The text after the $tt_$#by$#_ $rm is the string which
may replace the found string. If there is no $tt_$#by$#_ $rm then you may type
in the text and move on when R or E are used. Examples of `clever' replace
strings are:
.display
$tt _Any by _(_Found_)           $rm put brackets around every character
$tt (_Any_)_ by Field_0          $rm take above brackets away from characters
$tt _Many_ _Newline by Newline_  $rm strip trailing spaces
.endd
The search command will be repeated if just $tt RETURN $rm is typed. Or it can
be accessed by $tt COPY $rm for editing. Or the Global replace command may be
accessed by $tt SHIFT-COPY$rm.
.blank 2
.tempindent 0
$tt shift f4$rm$t Exit to language
.blank
After checking if there is any state to be saved, $it Twin $rm will exit to a
named language, the text being replaced into the language; or to the operating
system if just $tt RETURN $rm is typed. If $it Twin $rm has been called from a
language which provided a name (by $tt Twin @XXXXXXXX,XXXXXXXX: name$rm), then
it will prompt for a return to that langauge.
.blank 2
.tempindent 0
$tt ctrl f4$rm$t Modula2 Structure
.blank
To speed entry of programs $it Twin $rm contains instructions for common
$ss Modula 2 $rm structures, those being:
.display flow
$ss Case
Definition module
For
If
Loop
implementation Module
Procedure
Repeat
Type definition
While
$rm (Capital letter denotes active key)
.endd
For all structures indent rules are obeyed and comments are put on the
$ss END$rms. For the $ss Module $rm and $ss Procedure $rm a name is requested
which is put into the $ss END $rm statement (and into a file-naming comment in
the case of $ss Module$rm).
.blank 2
.tempindent 0
$tt f5$rm$t Global Replace
.blank
Whole file replace, or between mark and cursor. Syntax exactly as find string.
Displays the number of found objects after working. If no replace part is
specified $tt_$#by$#_ $rm then only the count of found objects will be
displayed.
.blank 2
.tempindent 0
$tt shift f5$rm$t Set Mode
.blank
Change mode. Only $ss BBC $rm screen modes $tt 0 $rm and $tt 3 $rm may be
used (80*32 and 80*25 respectively): $tt 0 $rm and $tt 3 $rm select either of
these operating modes. When in a particular screen mode $tt D $rm
(Descriptive mode), $tt K $rm (key legend mode) and $tt T $rm (Time display
mode) may be selected. Naturally the displays on screen are less pretty when
a 25 line mode is being used.

When Twin starts up it will select either 32 line mode or 25 line mode. It
does this with a $tt BYTE $rm call (see Brazil manual) with R0=161, R1=8,
R2=0: if the bottom two bits of R2 are zero then mode 0 is used, otherwise
mode 3 is used. This means that a standard BBC machine or B+ will start in
mode 0, a Master will start in 0 or 3 (the call returns state from CMOS RAM:
change it by using Edit on the IO processor: Twin starts up in Edit's mode)
and the Twin on IBM PC starts in mode 3 since that operating system
specifically returns 3.
.blank 2
.tempindent 0
$tt ctrl f5$rm$t Enter Character
.blank
This allows the entry of any character (0 to 255) into the text. The character
can either be typed directly from the keyboard (e.g. $tt RETURN $rm to enter
character &0D) or entered in decimal.
.blank 2
.tempindent 0
$tt ctrl shift f5$rm$t Pop Buffer
.blank
A `Pushed' buffer will be recovered from its stack.
.blank 2
.tempindent 0
$tt f6$rm$t Mark Place
.blank
When pressed, the character that the cursor is on will be replaced by an
inverted $tt 1 $rm or $tt 2 $rm and the number of marks displayed at the
bottom left of the screen will be increased. Marked positions can be used to
delete blocks of text, copy and move them, perform restricted searches or
saves or even just to remember where something is. Up to two marked positions
may be set in each buffer, an attempt to set a third will produce an error
message.
.blank 2
.tempindent 0
$tt shift f6$rm$t Clear Marks
.blank
Removes all marks in the current window.
.blank 2
.tempindent 0
$tt ctrl f6$rm$t Format Paragraph
.blank
Format from the start of the line that the cursor is on until the end of the
paragraph, that is NewLine followed by a character that is less than or equal
to Space or one of `,.;:'. The length of the lines produced is less than or
equal to 78 characters. This is useful for Mail or GCAL source.
.blank 2
.tempindent 0
$tt ctrl shift f6$rm$t Push Buffer
.blank
The current text is `pushed' onto a stack (one stack for each buffer). The
buffer is cleared and the number at the bottom left of the screen increments
to show how many stacked buffers there are.

Pushing buffers will cause the Connect to buffer command to fail.
.blank 2
.tempindent 0
$tt f7$rm$t Marked Copy
.blank
Copies text delimited by two marks to where the cursor is now. The marks are
not cleared so the operation can be repeated. The cursor must not be inside the
marked area, although it can be on the last mark. If there are no marks set in
the current window then text marked by two marks in the other window can be
copied.
.blank 2
.tempindent 0
$tt shift f7$rm$t Marked Move
.blank
Moves text delimited by two marks to where the cursor is now. The marks are
cleared. The cursor must not be in the marked area.
.blank 2
.tempindent 0
$tt ctrl f7$rm$t Mail
.blank
Mails all text in the current buffer to the specified name on $ss Econet $rm
or $ss Ecomail to VAX$rm. $it Twin $rm first tries $tt ~~$.EcoMail.Out.<name>$rm,
then it tries $tt ~~$.<name>.MailBox$rm. Obviously you must be logged on
to the fileserver. After sending the mail, the current filing system will be
reselected.
.blank 2
.tempindent 0
$tt f8$rm$t Print text
.blank
Prints out the text to the current printer. Two options for printing the
buffer are provided:

As is: prints out the text as it is in the buffer e.g. for PostScript files or
for program listings.

GCAL: use the GCAL formatter to convert the text to GCODE. Then the $tt f1 $rm
prompt appears so that one of PSGTYPE or GTYPE can be used to look at the
formatted version.
.blank 2
.tempindent 0
$tt shift f8$rm$t Marked Delete
.blank
Deletes text between single marked position and current cursor position. The
text cannot be recovered.
.blank 2
.tempindent 0
$tt ctrl f8$rm$t Swap LF and CR
.blank
Some documents may have been prepared using $tt CR (&0D) $rm as a terminating
character. This key interchanges all $tt LF $rm and $tt CR $rm codes.
.blank 2
.tempindent 0
$tt ctrl shift f8$rm$t Auto Task Bottom
.blank
$tt ctrl shift f8 $rm toggles the $ss TaskLinked/TaskUnlinked $rm state.
See the $tt ctrl f9 $rm entry.
.blank 2
.tempindent 0
$tt f9$rm$t Old text
.blank
Nominally supposed to recover the old text in the machine after a New Text or
pressing $tt BREAK $rm and re-running $it Twin$rm. However it has not yet
been implemented and all it does is to print the number of free bytes.
.blank 2
.tempindent 0
$tt shift f9$rm$t Clear text
.blank
Delete all text. Reset to $ss Original$rm. $it Twin $rm will ask if date
stamping should be used (answer $tt Y$rm, if the time has not been set in the
machine then date stamping will be disabled) or file system auto exec mode
(for use by rune-masters). The text buffer can also be marked "Discarded" by
replying `D' - in this case, although one might alter the buffer by typing to
it etc. Twin will not generate any of the safety prompts.
.blank 2
.tempindent 0
$tt ctrl f9$rm$t Task Status
.blank
$it Twin $rm can run a task without affecting normal editing.

Output from the task to the screen (i.e. $tt Brazil WriteC, WriteI $rm etc.)
goes into the text buffer at the end: it is then painted on the screen by
$it Twin $rm (as a $it Called-back $rm program). The cursor position in the
text buffer is either forced to the end of the buffer $ss (TaskLinked) $rm
when the window is painted or under the control of the user
$ss (TaskUnLinked)$rm.

$tt ctrl-shift f8 $rm toggles the $ss TaskLinked/TaskUnlinked $rm state.

$rm $tt ctrl-shift#f9 $rm takes one to the end of the task buffer whichever
window is currently selected.

Characters typed in the range $tt &00 to &7F $rm are directed to the task
when in the task window: a marked copy operation also directs all its
characters to the task.

The task window may be resized or removed from the screen entirely.

When the task is started half of the available memory is allocated to it for
the output: this will be used up gradually, but there is no check for running
out of memory.

The swapping between the task and the main $it Twin $rm functionality is
performed by $tt Events $rm from the $ss BBC IO $rm system: conequently the
task is denied the use of events. $it Twin $rm swaps the environments created
by $tt Control $rm and $tt SetEnv $rm as swapping between itself and the task
occurs: thus $tt ESCAPEs $rm will be sent to the task as will errors.

When a task is running one must be careful not to change the CSD or filing
system: this will confuse things no end unless one has a project B machine.
.blank 2
.tempindent 0
$tt ctrl shift f9$rm$t Task Bottom
.blank
Puts the text pointer in the task window at the bottom if the task is running:
otherwise goes to the end of the current window.
.blank 2
.tempindent 0
$tt TAB$rm
.blank
The TAB key will either move the cursor to the next fixed zone of 8 columns on
the screen or it will position the cursor under the next non-space character
of the above line. The state of TAB is shown on the status line of the buffer.
.blank 2
.tempindent 0
$tt shift TAB$rm
.blank
alters the TAB action.
.blank 2
.tempindent 0
$tt COPY$rm
.blank
deletes the character at the cursor, causing the rest of the line to move left.
.blank 2
.tempindent 0
$tt shift COPY$rm
.blank
enters $ss Cursor Editing $rm mode. The 10 soft keys now generate their normal
strings, $tt TAB $rm enters $tt ctrl I $rm (the $tt ASCII TAB $rm code), and
the beeb's cursor editing system (arrow keys and $tt COPY$rm) is enabled.
Escape to leave this mode.
.blank 2
.tempindent 0
$tt ctrl COPY$rm
.blank
deletes from the start of this line to the next carriage return.
.blank 2
.tempindent 0
$tt DELETE$rm
.blank
deletes the character to the left of the cursor. In $ss Insert $rm mode the
text will shrink, in $ss Over $rm mode the text will not move.
.blank 2
.tempindent 0
/|\
.blank
Move up one line, scroll the screen down if at the top scroll margin.
.blank 2
.tempindent 0
$tt shift /|\$rm
.blank
Move up one screenfull.
.blank 2
.tempindent 0
$tt ctrl /|\$rm
.blank
Move to start of text
.blank 2
.tempindent 0
$tt ctrl shift /|\$rm
.blank
Move both windows up one screenfull at once. Due to the action of ctrl shift
in the BBC machine halting output it may be necessary to release the ctrl
shift keys to allow $it Twin $rm to finish updating the screen: this will only
happen if there is a line 80 characters or longer in either window.
.blank 2
.tempindent 0
\|/
.blank
Move down one line, scroll the screen up if at the bottom scroll margin.
.blank 2
.tempindent 0
$tt shift \|/$rm
.blank
Move down one screenfull.
.blank 2
.tempindent 0
$tt ctrl \|/$rm
.blank
Move to start of text
.blank 2
.tempindent 0
$tt ctrl shift \|/$rm
.blank
Move both windows down one screenfull at once. Due to the action of ctrl shift
in the BBC machine halting output it may be necessary to release the ctrl shift
keys to allow $it Twin $rm to finish downdating the screen: this will only
happen if there is a line 80 characters or longer in either window.
.blank 2
.tempindent 0
-->
.blank
Move right one character.
.blank 2
.tempindent 0
$tt shift -->$rm
.blank
Move right one word.
.blank 2
.tempindent 0
$tt ctrl -->$rm
.blank
Move to the extreme right hand end of the current line.
.blank 2
.tempindent 0
<--
.blank
Move left one character.
.blank 2
.tempindent 0
$tt shift <--$rm
.blank
Move left one word.
.blank 2
.tempindent 0
$tt ctrl <--$rm
.blank
Move to the extreme left hand end of the current line.
.indent 0
.section Dated files
In order to allow advanced tools to run, files can be date stamped. The date
is maintained in the software clock on the BBC machine: the program
$ss SetTime $rm will initialise this clock from a network fileserver, or the
program $ss Date $rm will allow the date to be typed in by the user. When the
date has been set in the BBC machine $it Twin $rm will start up with the
current date on the status line. The date of the file will be updated when the
file is saved. If the date in the BBC machine has not been set, $it Twin $rm
will start up for a command file: an attempt to save a dated file will be
queried.
.section Moving Twin
The version of $it Twin $rm on the net runs at $tt &1D0000 $rm in 2 or 4MByte
ARM 2nd processors, $tt &D0000 $rm in 1Mbyte processors, or $tt &10000 $rm in
1/4Mbyte processors, Brazil performing the translation automatically. Note
that Brazil cannot deal with the $tt &3D0000 $rm address in a 2MByte machine
or any high address in an A500 2nd processor. This gives either 3/4 or 1/4 of
the machine to background tasks. Simply changing the load and execute
addresses of $it Twin $rm will move it around the memory map to meet
particular needs e.g. moving it to $tt &90000 $rm will allow bigger source
files to be edited on the 1Mbyte machine (same size source files on the
1/4Mbyte machine). An automated moving program `$tt MoveFile$rm' simplifies
this procedure.

If one uses $tt f1 $rm to run something e.g. $tt AB$rm, under $it Twin $rm,
then that program gets memory from $tt &1000 $rm to the start of $it Twin $rm
i.e. $tt &D0000 $rm in the default case. Restarting the same $it Twin $rm from
inside AB is an error: the new incarnation of $it Twin $rm will complain that
there is no room and exit back to the old version of itself. Restarting
another, lower, version of $it Twin $rm is perfectly possible.
.section Using a Task
Suppose you want to recompile your $ss Modula 2 $rm world. The commands needed
to do this are:
.display flow
$tt m2dep   ;$rm modula 2 dependancy list
$tt m2make  ;$rm use dependancy list to make m2comp, the list of things to compile
$tt m2comp  ;$rm compile all programs

Build a command file to do this sequence by:

(1) clear text for command file (shift f9, shift f9)
(2) type in the list of things to do
(3) save it as, say, make

Now execute the command file as a task by typing control $tt f9 make.
.endd
Then you can edit files as normal in the other window: the text in the task
window being updated as output arrives (almost!). As errors arrive, load the
right source file and press control f3.
